home *** CD-ROM | disk | FTP | other *** search
/ Speccy ClassiX 1998 / Speccy ClassiX 98.iso / amiga_system / the_aminet / dev / gcc / ixemulsrc.lha / ixemul-41.4 / library / malloc.c < prev    next >
C/C++ Source or Header  |  1995-05-27  |  7KB  |  271 lines
  1. /*
  2.  *  This file is part of ixemul.library for the Amiga.
  3.  *  Copyright (C) 1991, 1992  Markus M. Wild
  4.  *
  5.  *  This library is free software; you can redistribute it and/or
  6.  *  modify it under the terms of the GNU Library General Public
  7.  *  License as published by the Free Software Foundation; either
  8.  *  version 2 of the License, or (at your option) any later version.
  9.  *
  10.  *  This library is distributed in the hope that it will be useful,
  11.  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12.  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13.  *  Library General Public License for more details.
  14.  *
  15.  *  You should have received a copy of the GNU Library General Public
  16.  *  License along with this library; if not, write to the Free
  17.  *  Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18.  *
  19.  *  malloc.c,v 1.1.1.1 1994/04/04 04:30:29 amiga Exp
  20.  *
  21.  *  malloc.c,v
  22.  * Revision 1.1.1.1  1994/04/04  04:30:29  amiga
  23.  * Initial CVS check in.
  24.  *
  25.  *  Revision 1.5  1992/10/20  16:26:17  mwild
  26.  *  change to single indirection to memory management list, allowing us
  27.  *  to switch lists on the fly (important for vfork).
  28.  *
  29.  *  Revision 1.4  1992/09/14  01:44:41  mwild
  30.  *  reduce magic cookie information by one long. By this, gcc's obstack will
  31.  *  allocate in neat 4k blocks, which makes GigaMem happy (GigaMem is a commercial
  32.  *  VMem package for AmigaDOS).
  33.  *
  34.  *  Revision 1.3  1992/08/09  20:58:57  amiga
  35.  *  add cast
  36.  *
  37.  *  Revision 1.2  1992/05/22  01:43:07  mwild
  38.  *  use buddy-alloc memory management
  39.  *
  40.  * Revision 1.1  1992/05/14  19:55:40  mwild
  41.  * Initial revision
  42.  *
  43.  */
  44.  
  45. #define KERNEL
  46. #include "ixemul.h"
  47. #include "kprintf.h"
  48.  
  49. #include <stddef.h>
  50.  
  51. #ifndef BARE_ALLOCMEM
  52. #define AllocMem    b_alloc
  53. #define FreeMem        b_free
  54. #endif
  55.  
  56. #define mem_list (u_save.u_mdp->md_list)
  57. #define mem_used (u_save.u_mdp->md_malloc_sbrk_used)
  58. #define own_mem_list (u_save.u_md.md_list)
  59. #define own_mem_used (u_save.u_md.md_malloc_sbrk_used)
  60.  
  61. #define MAGIC1 0x55555555
  62. #define MAGIC2 0xaaaaaaaa
  63.  
  64. /* use only one magic cookie at the end, since then the most frequently
  65.    done allocation of gcc, 4072 byte, fits neatly into 4096 when we've added
  66.    our information. Gigamem will thank you that it doesn't have to give
  67.    you an additional page for 4 byte ;-)) */
  68.  
  69. struct mem_block {
  70.   struct mem_block *next, *prev;
  71.   u_int           size;
  72.   u_int           magic[2];
  73.   u_int           realblock[1];
  74.   /* realblock should really be [0], and at the end we'd have a magic2[1] */
  75. };
  76.  
  77. struct memalign_ptr {
  78.   u_char    magic;
  79.   u_int        alignment:24;
  80. };
  81.  
  82. #define MEMALIGN_MAGIC 0xdd
  83.  
  84. /* perhaps important later ;-) */
  85. #define PAGESIZE 2048
  86.  
  87. void *
  88. malloc (size_t size)
  89. {
  90.   struct mem_block *res;
  91.  
  92.   /* guarantee long sizes (so we can use CopyMemQuick in realloc) */
  93.   size = (size + 3) & ~3; /* next highest multiple of 4 */
  94.   
  95.   /* include management information */
  96.   res = (struct mem_block *) AllocMem (size + sizeof (struct mem_block), 0); /* not MEMF_PUBLIC ! */
  97.   
  98.   if (res)
  99.     {
  100.       u_int *lp = &res->size;
  101.       *lp++ = size;
  102.       *lp++ = MAGIC1; *lp++ = MAGIC1;
  103.       lp = (u_int *)((u_char *)lp + size);
  104.       *lp++ = MAGIC2; 
  105.       
  106.       Forbid ();
  107.       AddTail ((struct List *) &mem_list, (struct Node *) res);
  108.       Permit ();
  109.  
  110.       mem_used += size;
  111.       return &res->realblock;
  112.     }
  113.  
  114.   return 0;
  115. }
  116.  
  117. void *
  118. memalign (size_t alignment, size_t size)
  119. {
  120.   u_char *p = (u_char *) malloc (size + alignment + sizeof (struct memalign_ptr));
  121.   struct memalign_ptr *al_start;
  122.  
  123.   if (! p)
  124.     return p;
  125.  
  126.   /* if the block is already aligned right, just return it */
  127.   if (! ((u_int)p & (alignment - 1)))
  128.     return p;
  129.  
  130.   /* else find the start of the aligned block in our larger block */
  131.   al_start = (struct memalign_ptr *)(((u_int)p + alignment - 1) & -alignment);
  132.  
  133.   /* this could be problematic on 68000, when an odd alignment is requested,
  134.    * should I just don't allow odd alignments?? */
  135.   al_start[-1].magic = MEMALIGN_MAGIC;
  136.   al_start[-1].alignment = (u_char *)al_start - p;
  137.  
  138.   return al_start;
  139. }
  140.  
  141. void *
  142. valloc (size_t size)
  143. {
  144.   return (void *) memalign (PAGESIZE, size);
  145. }
  146.  
  147. void
  148. free (void *mem)
  149. {
  150.   struct mem_block *block;
  151.   u_int *end_magic;
  152.  
  153.   /* this seems to be standard... don't like it though ! */
  154.   if (! mem)
  155.     return;
  156.  
  157.   block = (struct mem_block *)((u_char *)mem - offsetof (struct mem_block, realblock));
  158.  
  159.   if (((struct memalign_ptr *)mem - 1)->magic == MEMALIGN_MAGIC)
  160.     {
  161.       block = (struct mem_block *)
  162.           ((u_char *)block - ((struct memalign_ptr *)mem - 1)->alignment);
  163.     }
  164.  
  165.    
  166.  
  167.   if (((u_int)block & 1) ||
  168.       (block->magic[0] != MAGIC1 || block->magic[1] != MAGIC1))
  169.     {
  170.       ix_panic ("free: start of block corrupt!");
  171.       syscall (SYS_exit, 20);
  172.     }
  173.  
  174.   end_magic = (u_int *)((u_char *)&block->realblock + block->size);
  175.   if (end_magic[0] != MAGIC2)
  176.     {
  177.       ix_panic ("free: end of block corrupt!");
  178.       syscall (SYS_exit, 20);
  179.     }
  180.  
  181.   Forbid ();
  182.   Remove ((struct Node *) block);
  183.   Permit ();
  184.  
  185.   mem_used -= block->size;
  186.   FreeMem (block, block->size + sizeof (struct mem_block));
  187. }
  188.  
  189.  
  190. void
  191. all_free ()
  192. {
  193.   struct mem_block *b, *nb;
  194.  
  195.   /* be sure to use *our* memory lists in here, never all_free() the parents
  196.      list.... */
  197.   
  198.   for (b  = (struct mem_block *) own_mem_list.mlh_Head;
  199.        nb = b->next;
  200.        b  = nb)
  201.     {
  202.       FreeMem (b, b->size + sizeof (struct mem_block));
  203.     }
  204.  
  205.   /* this makes it possible to call all_free() more than once */
  206.   NewList ((struct List *) &own_mem_list);
  207.  
  208. }
  209.  
  210. void *
  211. realloc (void *mem, size_t size)
  212. {
  213.   struct mem_block *block;
  214.   u_int *end_magic;
  215.   void *res;
  216.  
  217.   if (! mem)
  218.     return (void *) malloc (size);
  219.     
  220.   block = (struct mem_block *)((u_char *)mem - offsetof (struct mem_block, realblock));
  221.  
  222.   
  223.   /* duplicate the code in free() here so we don't have to check those magic
  224.    * numbers twice */
  225.   
  226.   if (((struct memalign_ptr *)mem - 1)->magic == MEMALIGN_MAGIC)
  227.     {
  228.       block = (struct mem_block *)
  229.           ((u_char *)block - ((struct memalign_ptr *)mem - 1)->alignment);
  230.     }
  231.  
  232.    
  233.   if (((u_int)block & 1) ||
  234.       (block->magic[0] != MAGIC1 || block->magic[1] != MAGIC1))
  235.     {
  236.       ix_panic ("realloc: start of block corrupt!");
  237.       syscall (SYS_exit, 20);
  238.     }
  239.  
  240.   end_magic = (u_int *)((u_char *)&block->realblock + block->size);
  241.   if (end_magic[0] != MAGIC2)
  242.     {
  243.       ix_panic ("realloc: end of block corrupt!");
  244.       syscall (SYS_exit, 20);
  245.     }
  246.  
  247.   /* now that the block is validated, check whether we have to really
  248.    * realloc, or if we just can return the old block */
  249.   if (block->size >= size)
  250.     res = mem;
  251.   else
  252.     {
  253.       res = (void *) malloc (size);
  254.       if (res)
  255.     {
  256.       Forbid ();
  257.           Remove ((struct Node *) block);
  258.           Permit ();
  259.  
  260.       CopyMemQuick (mem, res, block->size);
  261.  
  262.       /* according to the manpage, the old buffer should only be
  263.        * freed, if the allocation of the new buffer was successful */
  264.       mem_used -= block->size;
  265.       FreeMem (block, block->size + sizeof (struct mem_block));
  266.     }
  267.     }
  268.  
  269.   return res;
  270. }
  271.